home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Software Vault: The Gold Collection
/
Software Vault - The Gold Collection (American Databankers) (1993).ISO
/
cdr05
/
xnot12a.zip
/
KEYMAP.C
< prev
next >
Wrap
C/C++ Source or Header
|
1993-06-11
|
21KB
|
885 lines
#include "jam.h"
/*
* Keyboard maps. This is character set dependent.
* The terminal specific parts of building the
* keymap has been moved to a better place.
*/
#include "def.h"
#include "kbd.h"
#define KEYMAP_C
#include "keyname.h"
/* hack for empty command
*/
int donothing(f,n)
int f,n;
{
return (TRUE);
}
static int rn_(name_fent,(char *fname, int flag));
/* initial keymap declarations, deepest first */
static PF cHcG[] = {
ctrlg, /* ^G */
help_help, /* ^H */
};
static PF cHa[] = {
apropos_command,/* a */
wallchart, /* b */
desckey, /* c */
};
static struct KEYMAPE(2+IMAPEXT) helpmap = {
2,
2+IMAPEXT,
rescan,
{
{CCHR('G'),CCHR('H'), cHcG,(KEYMAP *)NULL},
{'a', 'c', cHa, (KEYMAP *)NULL},
}
};
static PF cX4cF[] = {
poptofile, /* ^f */
ctrlg, /* ^g */
};
static PF cX4b[] = {
poptobuffer, /* b */
rescan, /* c */
rescan, /* d */
rescan, /* e */
poptofile, /* f */
};
static struct KEYMAPE(2+IMAPEXT) cX4map = {
2,
2+IMAPEXT,
rescan,
{
{CCHR('F'),CCHR('G'), cX4cF, (KEYMAP *)NULL},
{'b', 'f', cX4b, (KEYMAP *)NULL},
}
};
static PF cXcB[] = {
listbuffers, /* ^B */
quit, /* ^C */
rescan, /* ^D */
rescan, /* ^E */
filevisit, /* ^F */
ctrlg, /* ^G */
};
static PF cXcL[] = {
lowerregion, /* ^L */
rescan, /* ^M */
rescan, /* ^N */
deblank, /* ^O */
rescan, /* ^P */
rescan, /* ^Q */
rescan, /* ^R */
filesave, /* ^S */
rescan, /* ^T */
upperregion, /* ^U */
rescan, /* ^V */
filewrite, /* ^W */
swapmark, /* ^X */
};
static PF cXlp[] = {
definemacro, /* ( */
finishmacro, /* ) */
};
static PF cX0[] = {
delwind, /* 0 */
onlywind, /* 1 */
splitwind, /* 2 */
rescan, /* 3 */
prefix, /* 4 */
};
static PF cXeq[] = {
showcpos, /* = */
};
static PF cXcar[] = {
enlargewind, /* ^ */
rescan, /* _ */
rescan, /* ` */
rescan, /* a */
usebuffer, /* b */
rescan, /* c */
dired, /* d */
executemacro, /* e */
setfillcol, /* f */
rescan, /* g */
rescan, /* h */
fileinsert, /* i */
rescan, /* j */
killbuffer, /* k */
rescan, /* l */
rescan, /* m */
rescan, /* n */
nextwind, /* o */
rescan, /* p */
rescan, /* q */
rescan, /* r */
savebuffers, /* s */
};
static struct KEYMAPE(6+IMAPEXT) cXmap = {
6,
6+IMAPEXT,
rescan,
{
{CCHR('B'),CCHR('G'), cXcB, (KEYMAP *)NULL},
{CCHR('L'),CCHR('X'), cXcL, (KEYMAP *)NULL},
{'(', ')', cXlp, (KEYMAP *)NULL},
{'0', '4', cX0, (KEYMAP *)&cX4map},
{'=', '=', cXeq, (KEYMAP *)NULL},
{'^', 's', cXcar, (KEYMAP *)NULL},
}
};
static PF metacG[] = {
ctrlg, /* ^G */
};
static PF metacV[] = {
pagenext, /* ^V */
};
static PF metasp[] = {
justone, /* space */
};
static PF metapct[] = {
queryrepl, /* % */
};
static PF metami[] = {
negative_argument, /* - */
rescan, /* . */
rescan, /* / */
digit_argument, /* 0 */
digit_argument, /* 1 */
digit_argument, /* 2 */
digit_argument, /* 3 */
digit_argument, /* 4 */
digit_argument, /* 5 */
digit_argument, /* 6 */
digit_argument, /* 7 */
digit_argument, /* 8 */
digit_argument, /* 9 */
rescan, /* : */
rescan, /* ; */
gotobob, /* < */
rescan, /* = */
gotoeob, /* > */
};
static PF metalb[] = {
gotobop, /* [ */
delwhite, /* \ */
gotoeop, /* ] */
rescan, /* ^ */
rescan, /* */
rescan, /* - */
rescan, /* a */
backword, /* b */
capword, /* c */
delfword, /* d */
rescan, /* e */
forwword, /* f */
};
static PF metal[] = {
lowerword, /* l */
rescan, /* m */
rescan, /* n */
rescan, /* o */
rescan, /* p */
fillpara, /* q */
backsearch, /* r */
forwsearch, /* s */
rescan, /* t */
upperword, /* u */
backpage, /* v */
copyregion, /* w */
extend, /* x */
};
static PF metatilde[] = {
togglemodified, /* ~ */
delbword, /* DEL */
};
static struct KEYMAPE(8+IMAPEXT) metamap = {
8,
8+IMAPEXT,
rescan,
{
{CCHR('G'),CCHR('G'), metacG, (KEYMAP *)NULL},
{CCHR('V'),CCHR('V'), metacV, (KEYMAP *)NULL},
{' ', ' ', metasp, (KEYMAP *)NULL},
{'%', '%', metapct,(KEYMAP *)NULL},
{'-', '>', metami, (KEYMAP *)NULL},
{'[', 'f', metalb, (KEYMAP *)NULL},
{'l', 'x', metal, (KEYMAP *)NULL},
{'~', CCHR('?'), metatilde,(KEYMAP *)NULL},
}
};
static PF fund_at[] = {
setmark, /* ^@ */
gotobol, /* ^A */
backchar, /* ^B */
rescan, /* ^C */
forwdel, /* ^D */
gotoeol, /* ^E */
forwchar, /* ^F */
ctrlg, /* ^G */
prefix, /* ^H */
};
static PF fund_CI[] = {
alignindent, /* ^I */
};
/* ^I is selfinsert */
static PF fund_CJ[] = {
indent, /* ^J */
killline, /* ^K */
reposition, /* ^L */
newline, /* ^M */
forwline, /* ^N */
openline, /* ^O */
backline, /* ^P */
quote, /* ^Q */
backisearch, /* ^R */
forwisearch, /* ^S */
twiddle, /* ^T */
universal_argument, /* ^U */
forwpage, /* ^V */
killregion, /* ^W */
prefix, /* ^X */
yank, /* ^Y */
spawncli, /* ^Z */
};
static PF fund_esc[] = {
prefix, /* esc */
rescan, /* ^\ */ /* selfinsert is default on fundamental */
rescan, /* ^] */
rescan, /* ^^ */
rescan, /* ^_ */
};
static PF fund_del[] = {
backdel, /* DEL */
};
static PF blink_rp[] = {
showmatch, /* ) */
};
static struct KEYMAPE(3+IMAPEXT) blinkmap = {
3,
3+IMAPEXT,
rescan,
{
{')', ')', blink_rp, (KEYMAP *)NULL},
{'}', '}', blink_rp, (KEYMAP *)NULL},
{']', ']', blink_rp, (KEYMAP *)NULL},
}
};
#ifndef FUND_XMAPS
#define NFUND_XMAPS 0 /* extra map sections after normal ones */
#endif
static struct KEYMAPE(5+NFUND_XMAPS+IMAPEXT) fundmap = {
5 + NFUND_XMAPS,
5 + NFUND_XMAPS + IMAPEXT,
selfinsert,
{
{CCHR('@'),CCHR('H'), fund_at, (KEYMAP *)&helpmap},
{CCHR('I'),CCHR('I'), fund_CI, (KEYMAP *)&cXmap},
{CCHR('J'),CCHR('Z'), fund_CJ, (KEYMAP *)&cXmap},
{CCHR('['),CCHR('_'), fund_esc,(KEYMAP *)&metamap},
{CCHR('?'),CCHR('?'), fund_del,(KEYMAP *)NULL},
#ifdef FUND_XMAPS
FUND_XMAPS,
#endif
}
};
static PF fill_sp[] = {
fillword, /* ' ' */
};
static struct KEYMAPE(1+IMAPEXT) fillmap = {
1,
1+IMAPEXT,
rescan,
{
{' ', ' ', fill_sp, (KEYMAP *)NULL},
}
};
static PF indent_lf[] = {
newline, /* ^J */
rescan, /* ^K */
rescan, /* ^L */
indent, /* ^M */
};
static struct KEYMAPE(1+IMAPEXT) indntmap = {
1,
1+IMAPEXT,
rescan,
{
{CCHR('J'), CCHR('M'), indent_lf, (KEYMAP *)NULL},
}
};
static struct KEYMAPE(1+IMAPEXT) overwmap = {
0,
1+IMAPEXT, /* 1 to avoid 0 sized array */
rescan,
{
/* unused dummy entry for VMS C */
{(KCHAR)0, (KCHAR)0, (PF *)NULL, (KEYMAP *)NULL},
}
};
static PF dirednul[] = {
setmark, /* ^@ */
gotobol, /* ^A */
backchar, /* ^B */
rescan, /* ^C */
rescan, /* ^D */
gotoeol, /* ^E */
forwchar, /* ^F */
ctrlg, /* ^G */
prefix, /* ^H */
};
static PF diredcl[] = {
reposition, /* ^L */
forwline, /* ^M */
forwline, /* ^N */
rescan, /* ^O */
backline, /* ^P */
rescan, /* ^Q */
backisearch, /* ^R */
forwisearch, /* ^S */
rescan, /* ^T */
universal_argument, /* ^U */
forwpage, /* ^V */
rescan, /* ^W */
prefix, /* ^X */
};
static PF diredcz[] = {
spawncli, /* ^Z */
prefix, /* esc */
rescan, /* ^\ */
rescan, /* ^] */
rescan, /* ^^ */
rescan, /* ^_ */
forwline, /* SP */
};
static PF diredc[] = {
rescan, /* c */
rescan, /* d */
d_findfile, /* e */
d_findfile, /* f */
};
static PF diredn[] = {
forwline, /* n */
rescan, /* o */
backline, /* p */
rescan, /* q */
rescan, /* r */
rescan, /* s */
rescan, /* t */
rescan, /* u */
d_viewfile, /* v */
rescan, /* w */
rescan, /* x */
};
static PF direddl[] = {
rescan, /* del */
};
#ifndef DIRED_XMAPS
#define NDIRED_XMAPS 0 /* number of extra map sections */
#endif
static struct KEYMAPE(6 + NDIRED_XMAPS + IMAPEXT) diredmap = {
6 + NDIRED_XMAPS,
6 + NDIRED_XMAPS + IMAPEXT,
rescan,
{
{CCHR('@'), CCHR('H'), dirednul, (KEYMAP *)&helpmap},
{CCHR('L'), CCHR('X'), diredcl, (KEYMAP *)&cXmap},
{CCHR('Z'), ' ', diredcz, (KEYMAP *)&metamap},
{'c', 'f', diredc, (KEYMAP *)NULL},
{'n', 'x', diredn, (KEYMAP *)NULL},
{CCHR('?'), CCHR('?'), direddl, (KEYMAP *)NULL},
#ifdef DIRED_XMAPS
DIRED_XMAPS, /* map sections for dired mode keys */
#endif
}
};
static PF bufflstk[] = {
zapbuffer, /* k */
rescan, /* l */
rescan, /* m */
forwline, /* n */
rescan, /* o */
backline, /* p */
rescan, /* q */
rescan, /* r */
savethisbuffer, /* s */
rescan, /* t */
seebuffer, /* u */
};
/* piggy-backing off dired mode, this is bufferlist mode (JAM)
*/
#ifndef BUFFERL_XMAPS
#define NBUFFERL_XMAPS 0 /* number of extra map sections */
#endif
static struct KEYMAPE(5 + NBUFFERL_XMAPS + IMAPEXT) bufflstmap = {
5 + NBUFFERL_XMAPS,
5 + NBUFFERL_XMAPS + IMAPEXT,
rescan,
{
{CCHR('@'), CCHR('H'), dirednul, (KEYMAP *)&helpmap},
{CCHR('L'), CCHR('X'), diredcl, (KEYMAP *)&cXmap},
{CCHR('Z'), ' ', diredcz, (KEYMAP *)&metamap},
{'k', 'u', bufflstk, (KEYMAP *)NULL},
{CCHR('?'), CCHR('?'), direddl, (KEYMAP *)NULL},
#ifdef BUFFERL_XMAPS
BUFFERL_XMAPS, /* map sections for bufflst mode keys */
#endif
}
};
/* give names to the maps, for use by help etc.
* If the map is to be bindable, it must also be listed in the
* function name table below with the same name.
* Maps created dynamicly currently don't get added here, thus are unnamed.
* Modes are just named keymaps with functions to add/subtract them from
* a buffer's list of modes. If you change a mode name, change it in
* modes.c also.
*/
/* IF YOU ADD / DELETE MODES, YOU MUST!! update MODES.C */
MAPS map_table[] = {
/* fundamental map MUST be first entry */
{(KEYMAP *)&fundmap, "main"}, /* 0 */
{(KEYMAP *)&fillmap, "fill"}, /* 1 */
{(KEYMAP *)&indntmap, "indent"}, /* 2 */
{(KEYMAP *)&blinkmap, "C"}, /* 3 */
{(KEYMAP *)&overwmap, "overwrite"}, /* 4 */
{(KEYMAP *)&metamap, "esc prefix"}, /* 5 */
{(KEYMAP *)&cXmap, "c-x prefix"}, /* 6 */
{(KEYMAP *)&cX4map, "c-x 4 prefix"}, /* 7 */
{(KEYMAP *)&helpmap, "help"}, /* 8 */
{(KEYMAP *)&diredmap, "dired"}, /* 9 */
{(KEYMAP *)&bufflstmap, "blist"}, /* 10 (JAM) */
};
#define NMAPS (sizeof map_table/sizeof(MAPS))
int nmaps = NMAPS; /* for use by rebind in extend.c */
char *map_name(map)
KEYMAP *map;
{
MAPS *mp = &map_table[0];
do {
if(mp->p_map == map) return mp->p_name;
} while(++mp < &map_table[NMAPS]);
return (char *)NULL;
}
MAPS *name_mode(name)
char *name;
{
MAPS *mp = &map_table[0];
do {
if(strcmp(mp->p_name,name)==0) return mp;
} while(++mp < &map_table[NMAPS]);
return (MAPS *)NULL;
}
KEYMAP *name_map(name)
char *name;
{
MAPS *mp;
return ((mp=name_mode(name))==NULL ? (KEYMAP *)NULL : mp->p_map);
}
/* Warning: functnames MUST be in alphabetical order! (due to binary
* search in name_function.) If the function is prefix, it must be listed
* with the same name in the map_table above.
*/
static FUNCTNAMES CONSTANT functnames[] = {
/* NOTE - All functions which begin with "%-" are invisible to
* the user. They are used because it was easier than defining
* tons of 'exception' keycodes because during debugging I could
* 'hand test' the function. Absolute correctness would suggest that
* the whole concept of silent_extend (see extend.c) be dumped, and
* K_* codes be defined for all kinds of functions like these here
* and the forcing of command names as is done in *key.c for hard
* key mapping. In any case, the help layer won't print them out
* when doing a function dump and adding a new function to this table
* is exceptionally trivial exactly because silent_extend does exist (A
* big benefit right off is only this file needs recompiling vs all the
* files which use the keycode mapping tables). (JAM)
*/
{crashcheck, "%-crash-check"},
{d_findfile, "%-dired-find-file"}, /* moved and made */
{d_viewfile, "%-dired-view"}, /* invisible (JAM) */
#if 0 /* these were debug for something else.. */
{dosdir, "%-dosdir"},
{dosget, "%-dos-get-file-attr"},
{dosset, "%-dos-set-file-attr"},
#endif
{poptofilequiet,"%-efile"}, /* find-file w/prefilled fname */
{diredfiles_, "%-files"}, /* supports EFFILE, file name compl */
#ifdef WINDOWED
{mousecmd, "%-mouse"}, /* raw mouse input */
#endif
{shootmedead, "%-shootme"}, /* emergency exit */
{donothing, "%-zzzzz"}, /* empty event function */
{ManageAlarms, "alarms"},
{apropos_command, "apropos"},
{fillmode, "auto-fill-mode"},
{indentmode, "auto-indent-mode"},
{backchar, "backward-char"},
{delbword, "backward-kill-word"},
{gotobop, "backward-paragraph"},
{backword, "backward-word"},
{gotobob, "beginning-of-buffer"},
{gotobol, "beginning-of-line"},
{showthematch, "blink-match"},
{blinkparen, "blink-matching-paren"},
#ifdef BSMAP
{bsmap, "bsmap-mode"},
#endif
{CindentOff, "c-indent-off"},
{CindentOn, "c-indent-on"},
{prefix, "c-x 4 prefix"},
{prefix, "c-x prefix"},
{executemacro, "call-last-kbd-macro"},
{capword, "capitalize-word"},
{blinkparen, "cmode"},
{sysmake, "compile"}, /* duplicate access */
{copyregion, "copy-region-as-kill"},
#ifdef REGEX
{cntmatchlines, "count-matches"},
{cntnonmatchlines,"count-non-matches"},
#endif
{define_key, "define-key"},
{backdel, "delete-backward-char"},
{deblank, "delete-blank-lines"},
{forwdel, "delete-char"},
{delwhite, "delete-horizontal-space"},
#ifdef REGEX
{delmatchlines, "delete-matching-lines"},
{delnonmatchlines,"delete-non-matching-lines"},
#endif
{onlywind, "delete-other-windows"},
{delwind, "delete-window"},
{wallchart, "describe-bindings"},
{desckey, "describe-key-briefly"},
{digit_argument,"digit-argument"},
{dired, "dired"},
{lowerregion, "downcase-region"},
{lowerword, "downcase-word"},
{showversion, "emacs-version"},
{finishmacro, "end-kbd-macro"},
{gotoeob, "end-of-buffer"},
{gotoeol, "end-of-line"},
{enlargewind, "enlarge-window"},
{prefix, "esc prefix"},
{evalexpr, "eval-expression"},
{swapmark, "exchange-point-and-mark"},
{extend, "execute-extended-command"},
{fillpara, "fill-paragraph"},
{filevisit, "find-file"},
{poptofile, "find-file-other-window"},
{forwchar, "forward-char"},
{gotoeop, "forward-paragraph"},
{forwword, "forward-word"},
{bindtokey, "global-set-key"},
{unbindtokey, "global-unset-key"},
{gotoline, "goto-line"},
{gotomatch, "goto-match"}, /* matching paren, etc */
{hardtab, "hard-tab"},
{prefix, "help"},
{help_help, "help-help"},
{bufferinsert, "insert-buffer"},
{insert, "insert-chars"},
{fileinsert, "insert-file"},
{fillword, "insert-with-wrap"},
{backisearch, "isearch-backward"},
{forwisearch, "isearch-forward"},
{justone, "just-one-space"},
{ctrlg, "keyboard-quit"},
{killbuffer, "kill-buffer"},
{killline, "kill-line"},
{killpara, "kill-paragraph"},
{killregion, "kill-region"},
{delfword, "kill-word"},
{listbuffers, "list-buffers"},
{evalbuffer, "load-buffer"},
{evalfile, "load-file"},
{localbind, "local-set-key"},
{localunbind, "local-unset-key"},
#ifdef WINDOWED
# ifdef SomeUnix
{sysmail, "mail"},
# endif
{sysmake, "make"}, /* duplicate access */
#endif
{makebkfile, "make-backup-files"},
{negative_argument, "negative-argument"},
{newline, "newline"},
{indent, "newline-and-indent"},
#ifdef WINDOWED
{makeerror, "next-error"},
#endif
{forwline, "next-line"},
{openline, "open-line"},
{nextwind, "other-window"},
{myoverwrite, "overwrite-mode"},
{backline, "previous-line"},
{prevwind, "previous-window"},
/* {showcwdir, "pwd"}, useful?? it's in the title bar
and the current buffer info */
{queryrepl, "query-replace"},
#ifdef REGEX
{re_queryrepl, "query-replace-regexp"},
#endif
{quote, "quoted-insert"},
#ifdef REGEX
{re_searchagain,"re-search-again"},
{re_backsearch, "re-search-backward"},
{re_forwsearch, "re-search-forward"},
#endif
{reposition, "recenter"},
{myrefresh, "redraw-display"},
{filerevisit, "reread-file"},
{reverto, "revert-to-incremental"},
{filesave, "save-buffer"},
{quit, "save-buffers-kill-emacs"},
{savebuffers, "save-some-buffers"},
{backpage, "scroll-down"},
#ifdef GOSMACS
{back1page, "scroll-one-line-down"},
{forw1page, "scroll-one-line-up"},
#endif
{pagenext, "scroll-other-window"},
{forwpage, "scroll-up"},
{searchagain, "search-again"},
{backsearch, "search-backward"},
{forwsearch, "search-forward"},
{selfinsert, "self-insert-command"},
#ifdef WINDOWED
{NewWindowColor, "set-bg-color"},
#endif
#ifdef REGEX
{setcasefold, "set-case-fold-search"},
#endif
{set_default_mode, "set-default-mode"},
#ifdef WINDOWED
{NewTextColor, "set-fg-color"},
{NewTouchedTextColor, "set-fg2-color"},
#endif
{setfillcol, "set-fill-column"},
#ifdef WINDOWED
{NewFont, "set-font"},
#endif
{setmark, "set-mark-command"},
#ifdef WINDOWED /* duplicate color functions by other names */
{NewTextColor, "set-text-color"},
{NewTouchedTextColor, "set-touched-text-color"},
{NewWindowColor, "set-window-color"},
{ttwindowsize, "set-window-size"},
{spawncli2, "shell-command"},
# ifndef SomeUnix
{spawncli, "shell-window"},
# endif
#else /* WINDOWED */
# ifdef CURSES
{spawncli2, "shell-command"},
# else
{spawncli, "shell-command"},
# endif
#endif /* WINDOWED */
{showbufferfile, "show-filename"},
{shrinkwind, "shrink-window"},
{splitwind, "split-window-vertically"},
{definemacro, "start-kbd-macro"},
{usebuffer, "switch-to-buffer"},
{poptobuffer, "switch-to-buffer-other-window"},
{toggleverifytime, "toggle-check-file-timestamp"},
#ifdef DOCRYPT
{toggleencrypt, "toggle-encrypt-state"},
#endif
{togglejustnl,"toggle-just-write-newline"},
{togglemodified,"toggle-modified-state"},
{togglereadonly,"toggle-read-only"},
{toggleshowtouched,"toggle-show-touched-lines"},
#ifdef MSW
{togglemenu, "toggle-window-menu"},
#endif
{twiddle, "transpose-chars"},
{doUndo, "undo-last-undoable"},
{universal_argument, "universal-argument"},
#ifdef SomeUnix
{peerprog, "unix-exec"},
# else
/* below, in ABC order {windowprog, "win-exec"}, */
# endif
{upperregion, "upcase-region"},
{upperword, "upcase-word"},
{fileview, "view-file"},
{showcpos, "what-cursor-position"},
{showline, "what-line"}, /* GNU like */
#ifdef MSW
{windowprog, "win-exec"},
#else
/* above, in ABC order {peerprog, "unix-exec"}, */
#endif
{filewrite, "write-file"},
{yank, "yank"},
};
#define NFUNCT (sizeof(functnames)/sizeof(FUNCTNAMES))
int nfunct = NFUNCT; /* used by help.c */
/* Package a FUNCTNAMES entry for help processing;
* I like my data static. Call better be well behaved.
*/
BOOL loadfunct(i, pfnp)
int i;
void *pfnp;
{
FUNCTNAMES *fnp = (FUNCTNAMES *)pfnp;
bcopy(&functnames[i], fnp, sizeof(FUNCTNAMES));
return(TRUE);
}
/*
* The general-purpose version of ROUND2 blows osk C (2.0) out of the water.
* (reboot required) If you need to build a version of mg with less than 32
* or more than 511 functions, something better must be done.
* The version that should work, but doesn't is:
* #define ROUND2(x) (1+((x>>1)|(x>>2)|(x>>3)|(x>>4)|(x>>5)|(x>>6)|(x>>7)|\
* (x>>8)|(x>>9)|(x>>10)|(x>>11)|(x>>12)|(x>>13)|(x>>14)|(x>>15)))
*/
#define ROUND2(x) (x<128?(x<64?32:64):(x<256?128:256))
static int name_fent(fname, flag)
char *fname;
int flag;
{
register int tryit;
register int x = ROUND2(NFUNCT);
register int base = 0;
register int notit;
do {
/* + can be used instead of | here if more efficent.
*/
if((tryit = base | x) < NFUNCT) {
if((notit = strcmp(fname, functnames[tryit].n_name)) >= 0) {
if(!notit)
return (tryit);
base = tryit;
}
}
} while((x>>=1) || (tryit==1 && base==0)); /* try 0 once if needed */
return flag ? base : -1;
}
/*
* Translate from function name to function pointer, using binary search.
*/
PF name_function(fname)
char *fname;
{
int i;
if((i = name_fent(fname, FALSE)) >= 0)
return (functnames[i].n_funct);
return (PF)NULL;
}
/* complete function name
*/
int complete_function(fname, c)
register char *fname;
int c;
{
register int i, j, k, l;
int oj;
i = name_fent(fname, TRUE);
for(j=0; (l=(int)fname[j]) && functnames[i].n_name[j]==(char)l; j++)
{}
if(fname[j]!='\0')
{
if(++i >= NFUNCT)
return -2; /* no match */
for(j=0; (l=(int)fname[j]) && functnames[i].n_name[j]==(char)l; j++)
{}
if(fname[j]!='\0')
return -2; /* no match */
}
if(c==CCHR('M') && functnames[i].n_name[j]=='\0')
return -1;
for(k=i+1; k<NFUNCT; k++) { /* find last match */
for(l=0; functnames[k].n_name[l]==fname[l]; l++) {}
if(l<j)
break;
}
k--;
oj = j;
if(k>i) { /* multiple matches */
while((l = functnames[i].n_name[j]) == functnames[k].n_name[j]) {
fname[j++] = (char)l;
if(l=='-' && c==' ')
break;
}
if(j==oj) return -3; /* ambiguous */
} else { /* single match */
while(l = functnames[i].n_name[j]) {
fname[j++] = (char)l;
if(l=='-' && c==' ')
break;
}
}
fname[j] = '\0';
return j - oj;
}
/* translate from function pointer to function name.
*/
char *function_name(fpoint)
register PF fpoint;
{
register CONSTANT FUNCTNAMES *fnp = &functnames[0];
if(fpoint == prefix)
return (char *)NULL; /* ambiguous */
do {
if(fnp->n_funct == fpoint)
return fnp->n_name;
} while(++fnp < &functnames[NFUNCT]);
return (char *)NULL;
}